package yxkj;

import java.util.*;
import java.util.stream.Collectors;

public class Test {
    public static void main(String[] args) {
        List<Integer> lists = new ArrayList<>();
        lists.add(5);
        lists.add(6);
        lists.add(7);
        lists.add(8);

//        Integer num = getNum(lists);
//        System.out.println(num);

        Integer firstNum = getFirstNum(lists, 1);
        System.out.println(firstNum);
    }

    /**
     * 写一个函数，给定一个 List<lnteger> 和非负整数 K，
     * 返回 List中第一个 "与 List 中其他任意 Integer 的差值绝对值都大于 K” 的 Integer。
     * 若不存在，则返回 NULL
     *
     * @param lists
     * @param k
     * @return
     */
    private static Integer getFirstNum(List<Integer> lists, int k) {
        return lists.stream().collect(Collectors.groupingBy(x->x))
                .entrySet().stream().filter(x -> x.getValue().size() == 1) // 过滤掉出现两次以上的数字，不符合要求
                .filter(x -> lists.stream().filter(other -> other != x.getKey()) // 除去自己
                        .allMatch(other -> Math.abs(x.getKey() - other) > k)
                ) // 过滤出符合要求的数字
                .map(x -> x.getKey())
                .findFirst()
                .orElse(null);

//        return lists.stream().filter(num -> lists.stream()
//                .allMatch(other -> Math.abs(num - other) > k))
//                .findFirst()
//                .orElse(null);

//        for (int i = 0; i < lists.size(); i ++) {
//            // 标志位
//            boolean flag = true;
//            for (int j = 0; j < lists.size(); j ++) {
//                if (j == i) continue;
//                if (Math.abs(lists.get(i)-lists.get(j)) <= k) {
//                    flag = false;
//                    break;
//                }
//            }
//            // 如果一轮下来都符合
//            if (flag) {
//                return lists.get(i);
//            }
//        }
//        return null;

    }

    /**
     * 获取第一个只出现一次的数字
     * 若不存在，则返回 NULL
     *
     * @param lists
     * @return
     */
    private static Integer getNum(List<Integer> lists) {
//        // 分组
//        Map<Integer, List<Integer>> collect = lists.stream().collect(Collectors.groupingBy(x -> x));
//        // 统计
//        Map<Integer, Integer> map = new LinkedHashMap<>();
//        for (int i = 0; i < lists.size(); i ++) {
//            map.put(lists.get(i), map.getOrDefault(lists.get(i),0)+1);
//        }

        return lists.stream().collect(Collectors.groupingBy(x -> x)).entrySet().stream().filter(x -> x.getValue().size() == 1).findFirst().map(x -> x.getKey()).orElse(null);
//        return map.entrySet()
//                .stream()
//                .filter(x -> x.getValue() == 1)
//                .findFirst().map(x->x.getValue())
//                .orElse(null);
    }
}
